/***************************************************************************************
 * Copyright (c) 2014-2022 Zihao Yu, Nanjing University
 *
 * NEMU is licensed under Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan
 *PSL v2. You may obtain a copy of Mulan PSL v2 at:
 *          http://license.coscl.org.cn/MulanPSL2
 *
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY
 *KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
 *NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 *
 * See the Mulan PSL v2 for more details.
 ***************************************************************************************/

#include "sdb.h"
#include <cpu/cpu.h>
#include <isa.h>
#include <memory/paddr.h>
#include <readline/history.h>
#include <readline/readline.h>
#include <stdio.h>

static int is_batch_mode = false;

void init_regex();
void init_wp_pool();

/* We use the `readline' library to provide more flexibility to read from stdin.
 */
static char *rl_gets() {
  static char *line_read = NULL;

  if (line_read) {
    free(line_read);
    line_read = NULL;
  }

  line_read = readline("(nemu) ");

  if (line_read && *line_read) {
    add_history(line_read);
  }

  return line_read;
}

static int cmd_c(char *args) {
  cpu_exec(-1);
  return 0;
}

static int cmd_q(char *args) { return -1; }

static int cmd_si(char *args) {
  char *arg = strtok(NULL, " ");
  int n = 1;
  if (arg != NULL) {
    sscanf(arg, "%d", &n);
  }
  cpu_exec(n);
  return 0;
}

extern void isa_reg_display();

static int cmd_info(char *args) {
  char *arg = strtok(NULL, " ");
  if (arg == NULL) {
    printf("Please specify the info type.\n");
    return 0;
  }
  if (strcmp(arg, "r") == 0) {
    isa_reg_display();
  } else if (strcmp(arg, "w") == 0) {
    display_wp();
  } else {
    printf("Unknown info type '%s'.\n", arg);
  }
  return 0;
}

static int cmd_help(char *args);

static int cmd_p(char *args) {
  if (args == NULL) {
    printf("Please specify the expression.\n");
    return 0;
  }
  bool success = true;
  uint32_t result = expr(args, &success);
  if (success) {
    printf("%u\n", result);
  } else {
    printf("Invalid expression.\n");
  }
  return 0;
}

static int cmd_x(char *args) {
  char *arg = strtok(NULL, " ");
  if (arg == NULL) {
    printf("Please specify the number of bytes and the starting address.\n");
    return 0;
  }
  int n;
  sscanf(arg, "%d", &n);
  arg = strtok(NULL, " ");
  if (arg == NULL) {
    printf("Please specify the starting address.\n");
    return 0;
  }
  char _expr[128] = {0};
  bool success = true;
  sscanf(arg, "%s", _expr);
  vaddr_t addr = expr(_expr, &success);
  if (success) {
    for (int i = 0; i < n; i++) {
      if (i % 4 == 0) {
        printf("0x%08x: ", addr);
      }
      // read the virtural address content
      printf("0x%08x ", paddr_read(addr, 4));
      if (i % 4 == 3) {
        printf("\n");
      }
      addr += 4;
    }
    if (n % 4 != 0) {
      printf("\n");
    }
  } else {
    printf("Invalid expression.\n");
  }
  return 0;
}

static int cmd_w(char *args) {
  if (args == NULL) {
    printf("Please specify the watchpoint expression.\n");
    return 0;
  }
  
  bool success = true;
  uint32_t result = expr(args, &success);
  if (success) {
    printf("%u\n", result);
  } else {
    printf("Invalid expression.\n");
    assert(0);
  }
  WP *wp = new_wp();
  strcpy(wp->expr, args);
  wp->old_value = result;
  printf("Watchpoint %d: %s\n", wp->NO, wp->expr);
  return 0;
}

static int cmd_d(char *args) {
  char *arg = strtok(NULL, " ");
  if (arg == NULL) {
    printf("Please specify the watchpoint number.\n");
    return 0;
  }
  int n;
  sscanf(arg, "%d", &n);
  free_wp(n);
  return 0;
}

static struct {
  const char *name;
  const char *description;
  int (*handler)(char *);
} cmd_table[] = {
    {"help", "Display information about all supported commands", cmd_help},
    {"c", "Continue the execution of the program", cmd_c},
    {"q", "Exit NEMU", cmd_q},
    /* TODO: Add more commands */
    {"si", "Execute one instruction", cmd_si},
    {"info", "print the register or watchpoint", cmd_info},
    {"x", "Scan the memory", cmd_x},
    {"p", "print the value of variable", cmd_p},
    {"w", "set the watchpoint", cmd_w},
    {"d", "delete the watchpoint", cmd_d},

};

#define NR_CMD ARRLEN(cmd_table)

static int cmd_help(char *args) {
  /* extract the first argument */
  char *arg = strtok(NULL, " ");
  int i;

  if (arg == NULL) {
    /* no argument given */
    for (i = 0; i < NR_CMD; i++) {
      printf("%s - %s\n", cmd_table[i].name, cmd_table[i].description);
    }
  } else {
    for (i = 0; i < NR_CMD; i++) {
      if (strcmp(arg, cmd_table[i].name) == 0) {
        printf("%s - %s\n", cmd_table[i].name, cmd_table[i].description);
        return 0;
      }
    }
    printf("Unknown command '%s'\n", arg);
  }
  return 0;
}

void sdb_set_batch_mode() { is_batch_mode = true; }

void sdb_mainloop() {
  if (is_batch_mode) {
    cmd_c(NULL);
    return;
  }

  for (char *str; (str = rl_gets()) != NULL;) {
    char *str_end = str + strlen(str);

    /* extract the first token as the command */
    char *cmd = strtok(str, " ");
    if (cmd == NULL) {
      continue;
    }

    /* treat the remaining string as the arguments,
     * which may need further parsing
     */
    char *args = cmd + strlen(cmd) + 1;
    if (args >= str_end) {
      args = NULL;
    }

#ifdef CONFIG_DEVICE
    extern void sdl_clear_event_queue();
    sdl_clear_event_queue();
#endif

    int i;
    for (i = 0; i < NR_CMD; i++) {
      if (strcmp(cmd, cmd_table[i].name) == 0) {
        if (cmd_table[i].handler(args) < 0) {
          return;
        }
        break;
      }
    }

    if (i == NR_CMD) {
      printf("Unknown command '%s'\n", cmd);
    }
  }
}

void init_sdb() {
  /* Compile the regular expressions. */
  init_regex();

  /* Initialize the watchpoint pool. */
  init_wp_pool();
}
